Abstract: ZL is a C++-compatible language in which high-level constructs, such as classes, are defined using macros over a C-like core language. This approach makes many parts of the language easily customizable. For example, since the class construct can be defined using macros, a programmer can have complete control over the memory layout of objects. Using this capability, a programmer can mitigate certain problems in software evolution such as fragile ABIs (Application Binary Interfaces) due to software changes and incompatible ABIs due to compiler changes. In this paper, we outline the problem of fragile and incompatible ABIs and show how ZL can be used to solve them.

Abstract: This paper deals with embedded systems software and the modification of its architecture and behavior at execution-time. Incautious implementation of such capabilities demands heavy memory and performance overrun. To accomplish such software evolution activities in resource-constrained embedded systems, we propose a component-based run-time evolution infrastructure that reconciles richness of evolution alternatives and performance requirements. Our proposition is based on off-site components reifications, representations of components which allow us to treat evolution concerns remotely and hence to alleviate the workload to be processed by the embedded device. Memory and processor-time resources consumption evaluation on a real-world scenario show the efficiency and pertinence of our approach.

Abstract: Delta modeling is an approach to facilitate automated product derivation for software product lines. It is based on a set of deltas specifying modifications that are incrementally applied to a core product. The applicability of deltas depends on feature-dependent conditions. This paper presents abstract delta modeling, which explores delta modeling from an abstract, algebraic perspective. Compared to previous work, we take a more flexible approach with respect to conflicts between modifications and introduce the notion of conflict resolving deltas. We present conditions on the structure of deltas to ensure unambiguous product generation.

• Jeroen Arnoldus, Mark Van Den Brand and Alexander Serebrenik: Less is More: Unparser-completeness of Metalanguages for Template Engines

• Marko Rosenmueller, Norbert Siegmund, Mario Pukall and Sven Apel: Tailoring Dynamic Software Product Lines

• Don Batory, Peter Höfner and Jongwook Kim: Feature Interactions, Products, and Composition

• Vidar Slåtten, Frank Alexander Kraemer and Peter Herrmann: Towards Automatic Generation of Formal Specifications to Validate and Verify Reliable Distributed Systems - A Method Exemplified by an Industrial Case Study

• Yulin Li and Gordon Novak: Generation of Geometric Programs Specified by Diagrams

• Kenichi Asai: Reflection in Direct Style

• Abdelhakim Hannousse, Rémi Douence and Gilles Ardourel: Static Analysis of Aspect Interaction and Composition in Component Models

• Lais Neves, Leopoldo Teixeira, Demóstenes Sena, Vander Alves, Uirá Kulesza and Paulo Borba: Investigating the Safe Evolution of Software Product Lines

• Ricky T. Lindeman, Lennart C. L. Kats and Eelco Visser: Declaratively Defining Domain-Specific Language Debuggers

• Sander Vermolen, Guido Wachsmuth and Eelco Visser: Generating Database Migrations for Evolving Web Applications

• Sebastian Erdweg, Lennart C. L. Kats, Tillmann Rendel, Christian Kästner, Klaus Ostermann and Eelco Visser: Growing a Language Environment with Editor Libraries

• William R Otte, Aniruddha Gokhale, Douglas C. Schmidt and Johnny Willemsen: Infrastructure for Component-Based DDS Application Development

• Márcio Ribeiro, Felipe Queiroz, Paulo Borba, Társis Tolêdo, Claus Brabrand and Sérgio Soares: On the Impact of Feature Dependencies when Maintaining Preprocessor-based Software Product Lines

• John Freeman, Jaakko Jarvi, Wonseok Kim, Mat Marcus and Sean Parent: Helping Programmers Help Users

• Nathaniel Nystrom, Derek White and Kishen Das: Firepile: run-time compilation for GPUs in Scala

• Shahram Esmaeilsabzali, Bernd Fischer and Joanne Atlee: Monitoring Aspects for the Customization of Automatically Generated Code for Big-Step Models

• Patrick Gaubatz, Stefan Sobernig, Mark Strembeck and Uwe Zdun: The Effects of Programming Interface Design on Development Effort: An Experiment on DSL Integration in the Domain of Federated Identity Management

• Andreas Steck, Alex Lotz and Christian Schlegel: Model-Driven Engineering and Run-Time Model-Usage in Service Robotics

Abstract: Plug-in components are a means for making feature-rich applications customizable. Combined with plug-and-play composition, end users can assemble customized applications without programming. If plug-and-play composition is also dynamic, applications can be reconfigured on the fly to load only components the user needs for his current work. We have created Plux.NET, a plug-in framework that supports dynamic plug-and-play composition. The basis for plug-and-play in Plux is the composer which replaces programmatic composition by automatic composition. Components just specify their requirements and provisions using metadata. The composer then assembles the components based on that metadata by matching requirements and provisions. When the composer needs to reuse general-purpose components in different parts of an application, the component model requires genericity. The composer depends on metadata that specify which components should be connected and for general-purpose components those metadata need to be different on each reuse. We present an approach for generic plug-ins with component templates and an implementation for Plux. The general-purpose components become templates and the templates get parameterized when they are composed.

Abstract: While dynamic code evolution in object-oriented systems is an important feature supported by dynamic languages, there is currently only limited support for dynamic code evolution in high-performance, state-of-the-art runtime systems for statically typed languages, such as the Java Virtual Machine. In this tool demonstration, we present the Dynamic Code Evolution VM, which is based on a recent version of Oracle's state-of-the-art Java HotSpot(TM) VM and allows unlimited changes to loaded classes at runtime. Based on the Dynamic Code Evolution VM, we developed an enhanced version of the Mantisse GUI builder (which is part of the NetBeans IDE) that allows adding GUI components without restarting the application under development. Furthermore, we redesigned the dynamic AOP framework HotWave to take advantage of the enhanced dynamic code evolution capabilities. The new version, HotWave2, now supports most AspectJ constructs, including "around()" advice and static cross-cutting. We will demonstrate both the enhanced Mantisse GUI builder as well as HotWave2, weaving several aspects for dynamic analysis in sizable applications at runtime.

Abstract: Operation contracts consisting of pre- and postconditions are a well-known means of specifying operations. In this paper we deal with the problem of operation contract simulation, i.e. determining operation results satisfying the postconditions based on input data supplied by the user; simulating operation contracts is an important technique for requirements validation and prototyping. Current approaches to operation contract simulation exhibit poor performance for large sets of input data or require additional guidance from the user. We show how these problems can be alleviated and describe an efficient as well as fully automatic approach. It is implemented in our tool OCLexec that generates from UML/OCL operation contracts corresponding Java implementations which call a constraint solver at runtime. The generated code can serve as a prototype. A case study demonstrates that our approach can handle problem instances of considerable size.

Abstract: Function-block-based modeling is often used to develop embedded systems, particularly as system variants can be developed rapidly from existing modules. Generative approaches can simplify the handling and development of the resulting high variety of function-block-based models. But they often require the development of new generic models that do not utilize existing ones. Reusing existing models will significantly decrease the effort to apply generative programming. This work introduces an automatic approach to recognize variants in a set of models and identify the variation points and their dependencies within the variants. As result it offers automatically generated feature models and ICCL content to generate the given variants.

Please help us promote GPCE by including the following HTML code in your webpage, which will include the above image link to our website (you can change the width and height proportionally)

<a href="https://program-transformation.org/GPCE11" target="_blank">
<img title="Generative Programming and Component Engineering 2011" src="https://program-transformation.org/pub/GPCE11/Banner/gpce2011-banner.png" alt="GPCE2011" width="176" height="218"/>
</a>

CALL FOR PAPERS (txt^?,pdf^?)

---

Generative Programming and Component Engineering (GPCE'11)

Tenth International Conference
October 22-23, 2011
Portland, Oregon, USA
(collocated with SPLASH 2011)

Sponsored by ACM and SGT

Important Dates (NEW)

• Submission of abstracts: Saturday, May 21, 2011 (DEADLINE PASSED)
• Submission of papers: Saturday, May 28, 2011
• Author notification: Wednesday, July 6, 2011
• Submission of tech talks: August 7, 2011

Scope

Generative and component approaches are revolutionizing software development just as automation and componentization revolutionized manufacturing. Key technologies for automating program development are Generative Programming for program synthesis, Component Engineering for modularity, and Domain-Specific Languages (DSLs) for compact problem-oriented programming notations.

The International Conference on Generative Programming and Component Engineering is a venue for researchers and practitioners interested in techniques that use program generation and component deployment to increase programmer productivity, improve software quality, and shorten the time-to-market of software products. In addition to exploring cutting-edge techniques of generative and component-based software, our goal is to foster further cross-fertilization between the software engineering and the programming languages research communities.

Submissions

Research papers

10 pages in SIGPLAN proceedings style (sigplanconf.cls, see http://www.sigplan.org/authorInformation.htm) reporting original and unpublished results of theoretical, empirical, conceptual, or experimental research that contribute to scientific knowledge in the areas listed below (the PC chair can advise on appropriateness).

Tool demonstrations

Tool demonstrations should present tools that implement generative and component-based software engineering techniques, and are available for use. Any of the GPCE'11 topics of interest are appropriate areas for tool demonstrations. Purely commercial tool demonstrations will not be accepted. Submissions should contain a tool description of up to 6 pages in SIGPLAN proceedings style (sigplanconf.cls) and a demonstration outline of up to 2 pages text plus 2 pages screen shots. The six page description will, if the demonstration is accepted, be published in the proceedings. The 2+2 page demonstration outline will only be used by the PC for evaluating the submission.

Workshops and Tech Talks

Workshops are organized by SPLASH - see the SPLASH Call for Workshops for details. Tech talks are organized by GPCE as one or two talks at the end of each day of the conference. The talks will be about an hour in length and, similarly to tutorials, do not (need to) present original new research material. Unlike longer tutorials, these talks cannot be very interactive, and should instead aim to be 'keynote' style presentations. Please see the tech talks call for contributions for details.

Topics

GPCE seeks contributions in software engineering and in programming languages related (but not limited) to:

• Generative programming
  • Reuse, meta-programming, partial evaluation, multi-stage and multi-level languages, step-wise refinement, generic programming, automated code generation
  • Semantics, type systems, symbolic computation, linking and explicit substitution, in-lining and macros, templates, program transformation
  • Runtime code generation, compilation, active libraries, synthesis from specifications, development methods, generation of non-code artifacts, formal methods, reflection

• Generative techniques for
  • Product-line architectures
  • Distributed, real-time and embedded systems
  • Model-driven development and architecture
  • Resource bounded/safety critical systems.

• Component-based software engineering
  • Reuse, distributed platforms and middleware, distributed systems, evolution, patterns, development methods, deployment and configuration techniques, formal methods

• Integration of generative and component-based approaches

• Domain engineering and domain analysis
  • Domain-specific languages including visual and UML-based DSLs

• Separation of concerns
  • Aspect-oriented and feature-oriented programming,
  • Intentional programming and multi-dimensional separation of concerns

• Applications of the above in industrial scenarios or to real-world problems, bridging the gap between theory and practice

• Empirical studies
  • Original work in any of the areas above where there is a substantial empirical dimension to the work being presented. Such contributions might take the form of a case/field study, comparative analysis, controlled experiment, survey or meta-analysis of previous studies.

Incremental improvements over previously published work should have been evaluated through systematic, comparative, empirical, or experimental evaluation. Submissions must adhere to SIGPLAN's republication policy (http://www.sigplan.org/republicationpolicy.htm). Please contact the program chair if you have any questions about how this policy applies to your paper (chairs@gpce.org).

Organization

Chairs (chairs@gpce.org)

• General Chair: Ewen Denney (SGT/NASA Ames, USA)
• Program Chair: Ulrik Pagh Schultz (University of Southern Denmark, Denmark)
• Publicity Chair: Chang Hwan Peter Kim (University of Texas at Austin, USA)

Program Committee

• Andrzej Wąsowski (IT University of Copenhagen, Denmark)
• Anirüddhā Gokhālé (Vanderbilt University, USA)
• Bernd Fischer (University of Southampton, UK)
• Bruno C. d. S. Oliveira (Seoul National University, Korea)
• Christian Kästner (Philipps Universitat Marburg, Germany)
• Chung-Chieh Shan (Rutgers, The State University of New Jersey, USA)
• Don Batory (University of Texas at Austin, USA)
• Eli Tilevich (Virginia Tech, USA)
• Eric Tanter (University of Chile, Chile)
• Görel Hedin (Lund Institute of Technology, Sweden)
• Ina Schaefer (TU Braunschweig, Germany)
• Jeremiah Willcock (Indiana University, USA)
• Jeremy Siek (University of Colorado at Boulder, USA)
• Jurgen Vinju (Centrum Wiskunde en Informatica, The Netherlands)
• Lionel Seinturier (University of Lille, France)
• Marjan Mernik (University of Maribor, Slovenia)
• Mat Marcus (Adobe Systems, USA)
• Nicolas Loriant (INRIA, France)
• Ras Bodik (University of California at Berkeley, USA)
• Robert Glück (University of Copenhagen, Denmark)
• Steffen Zschaler (King's College London, UK)
• Tudor Girba (netstyle.ch, Switzerland)
• Walter Binder (University of Lugano, Switzerland)
• Yanhong A. Liu (State University of New York at Stony Brook, USA)

CALL FOR TECH TALKS

---

Generative Programming and Component Engineering (GPCE'11)

Tenth International Conference
October 22-23, 2011
Portland, Oregon, USA
(collocated with SPLASH 2011)

Sponsored by ACM and SGT

Important dates

• Submission of tech talk proposals: August 7, 2011
• Author notification: August 26, 2011

Scope

Tech talks are organized by GPCE as one or two talks at the end of each day of the conference (Saturday October 22nd and Sunday October 23rd). The talks will be about an hour in length; longer than a regular conference talk, but shorter than the customary half or full day tutorials at other conferences. In contrast to research talks, tech talks do not (have to) present original new research material, but should rather focus on putting research into perspective for a broader audience. In contrast to longer tutorials, these talks cannot be very interactive or rely on the audience participating by using tools. Rather, they should aim to be 'keynote' style presentations, emphasizing the essence (but not avoiding depth).

They can be thought of as distilled tutorials that provide a focused and in-depth treatment of specific research results considered relevant to the GPCE community.

Moreover, the tech talks are included in the conference registration and are not charged separately. We hope that this will ensure high impact of the tech talks.

Submission

If you are interested in presenting a tech talk at GPCE, please send a short proposal (about two pages) to the conference chairs (chairs@gpce.org) by August 7, 2011.

The proposal should consist of

1. title
2. abstract (250 words)
3. name of presenter
4. short bio (250 words)
5. brief outline of tech talk
6. relevance for GPCE/SPLASH audience

Items 1 to 4 should be usable on the website.

We will make a selection of tech talks based on relevance (topic-wise) for the conference and expected interest in the tech talk. Tech talk proposers will be notified of the decision by August 26, 2011.

Abstract: Some limitations of object-oriented mechanisms are known to cause code clones (e.g., extension using inheritance). Novel programming paradigms such as feature-oriented programming (FOP) aim at alleviating these limitations. However, it is an open issue whether FOP is really able to avoid code clones or whether it even facilitates (FOP-specific) clones. To address this issue, we conduct an empirical analysis on ten feature-oriented software product lines with respect to code cloning. We found that there is a considerable amount of clones in feature-oriented software product lines and that a large fraction of these clones is FOP-specific (i.e., caused by limitations of feature-oriented mechanisms). Based on our results, we initiate a discussion on the reasons for FOP-specific clones and on how to cope with them.

Abstract: Aspect-oriented programming provides a convenient high-level model to define several kinds of dynamic analyses, in particular thanks to recent advances in exhaustive weaving in core libraries. Casting dynamic analyses as aspects allows the use of a single weaving infrastructure to apply different analyses to the same base program, simultaneously. However, even if dynamic analysis aspects are mutually independent, their mere presence perturbates the observations of others: this is due to the fact that aspectual computation is potentially visible to all aspects. Because current aspect composition approaches do not address this kind of computational interference, combining different analysis aspects yields at best unpredictable results. It is also impossible to flexibly combine various analyses, for instance to analyze an analysis aspect. In this paper we show how the notion of execution levels makes it possible to effectively address these composition issues. In order to realize this approach, we explore the practical and efficient integration of execution levels in a mainstream aspect language, AspectJ. We report on a case study of composing two out-of-the-box analysis aspects in a variety of ways, highlighting the benefits of the approach.

Generative Programming and Component Engineering (GPCE'11)

Tenth International Conference
October 22-23, 2011
Portland, Oregon, USA
(collocated with SPLASH 2011)

Sponsored by ACM and SGT

• Ewen Denney (SGT/NASA Ames, USA)

Program Chair:

• Ulrik Pagh Schultz (University of Southern Denmark, Denmark)

Program Committee Members:

• Andrzej Wąsowski (IT University of Copenhagen, Denmark)
• Anirüddhā Gokhālé (Vanderbilt University, USA)
• Bernd Fischer (University of Southampton, UK)
• Bruno C. d. S. Oliveira (Seoul National University, Korea)
• Christian Kästner (Philipps Universitat Marburg, Germany)
• Chung-chieh Shan (Cornell University, USA)
• Don Batory (University of Texas at Austin, USA)
• Eli Tilevich (Virginia Tech, USA)
• Eric Tanter (University of Chile, Chile)
• Görel Hedin (Lund University, Sweden)
• Ina Schaefer (TU Braunschweig, Germany)
• Jeremiah Willcock (Indiana University, USA)
• Jeremy Siek (University of Colorado at Boulder, USA)
• Jurgen Vinju (Centrum Wiskunde en Informatica, The Netherlands)
• Lionel Seinturier (University of Lille, France)
• Marjan Mernik (University of Maribor, Slovenia)
• Mat Marcus (Canyonlands Software Design, USA)
• Nicolas Loriant (Imperial College, UK)
• Ras Bodik (University of California at Berkeley, USA)
• Robert Glück (University of Copenhagen, Denmark)
• Steffen Zschaler (King's College London, UK)
• Tudor Girba (netstyle.ch, Switzerland)
• Walter Binder (University of Lugano, Switzerland)
• Yanhong A. Liu (State University of New York at Stony Brook, USA)

Publicity Chair:

• Chang Hwan Peter Kim (University of Texas at Austin, USA)

Steering Committee:

• Bernd Fischer (UK), (2011-)
• Charles Consel Chair (FR), (2007-)
• Eelco Visser (NL), (2008-)
• Jaakko Jarvi (US), (2010-)
• Jeremy Siek (US) (2008-)
• Julia Lawall (DK), Chair (2008-)

Registration: Salon Foyer (Hilton Executive Tower, downstairs)

Conference location: Salon Ballroom I and II (Hilton Executive Tower, downstairs)

Saturday, October 22

Sunday, October 23

GPCE 2011 will be held at Hilton Portland and Executive Tower, 921 SW Sixth Avenue, Portland, Oregon, co-located with SPLASH 2011.

See hotel website for more information.

Portland

Portland is a city located in northwestern part of United States, in the state of Oregon. Portland, with city population of around 582,130 and metropolitan area population of around 2.2 million, is Oregon's most populous city. The city is well known for its environmental friendliness, nice parks, botanic gardens and museums. It is also a great place to dine, with its excellent restaurants and over 25 excellent microbreweries. Portland's Marine west coast climate makes it an ideal place to grow roses, so much so that it has been known as the "City of Roses" that has many rose gardens. Also, Portland's close proximity to beautiful sceneries including Mount Hood, Columbia River, and Multnomah Falls makes it a great place to tour.

Travel

Portland can be reached by air, rail and road.

Planes

All major airlines fly to Portland. See Portland International Airport website for more information.

Directions to the Hotel

The Hilton is located in downtown Portland. Here is a map:

View Larger Map

Abstract:

Tool support is vital to the effectiveness of domain-specific languages. With language workbenches, domain-specific languages and their tool support can be generated from a combined, high-level specification. This paper shows how such a specification can be extended to describe a debugger for a language. To realize this, we introduce a meta-language for coordinating the debugger that abstracts over the complexity of writing a debugger by hand. We describe the implementation of a language-parametric infrastructure for debuggers that can be instantiated based on this specification. The approach is implemented in the Spoofax language workbench and validated through realistic case studies with the Stratego transformation language and the WebDSL web programming language.

Abstract: Smooth integration of domain-specific languages into a general purpose host language requires absorbing of domain code written in arbitrary syntax. The integration should cause minimal syntactical and semantic overhead and introduce minimal dependency on external tools. In this paper we discuss a DSL integration technique for the C++ programming language. The solution is based on compile-time parsing of the DSL code. The parser generator is a C++ template metaprogram reimplementation of a runtime Haskell parser generator library. The full parsing phase is executed when the host program is compiled. The library uses only standard C++ language features, thus our solution is highly portable. As a demonstration of the power of this approach, we present a highly efficient and type-safe version of printf and the way it can be constructed using our library. Despite the well known syntactical difficulties of C++ template metaprograms, building embedded languages using our library leads to self-documenting C++ source code.

Abstract: The CPP is the dominant tool of choice for the implementation of variability in large-scale configurable software. Linux, probably the most-configurable piece of software ever, employs more than 10,000 preprocessor variables for this purpose. However, this de-facto variability tends to be ``hidden in the code''; which on the long term leads to varibility defects, such as dead code or inconsistencies with respect to the intended (modelled) variability of the software. This calls for tool support for the efficient extraction of (and reasoning over) CPP-based variability.

We suggest a novel approach to extract CPP-based variability. Our tool transforms CPP-based variability in O(n) complexity into a propositional formula that ``mimics'' all valid effects of conditional compilation and can be queried with standard SAT or BDD packages.

Our evaluation results demonstrate the scaleability and practicability of the approach. A dead-block-analysis on the complete Linux source tree takes less than 15 minutes; we thereby have revealed 4 defects, 2 of which meanwhile have been confirmed as new (and long-lasting) bugs.

Abstract: The relationship between feature modules and feature interactions is not well-understood. To explain classic examples of feature interaction, we show that features are not only composed sequentially, but also by cross-product and interaction operations that heretofore were implicit in the literature. Using the CIDE tool as our starting point, we (a) present a formal model of these operations, (b) show how it connects and explains previously unrelated results in Feature Oriented Software Development (FOSD), and (c) describe a tool, based on our formalism, that demonstrates how changes in composed documents can be back-propagated to their original feature module definitions, thereby improving FOSD tooling.

Application of Model Based Development to Flexible Code Generation

Gary Shubert, Lockheed Martin Space Systems Company, USA

This address will present the author's views and perspectives on the past, present and future use of model based development techniques to enable the automated generation of source code and other forms of programming. This address will discuss past and present use of model based development and automated code generation at Lockheed Martin, with special emphasis on NASA's Orion Multi-Purpose Crew Vehicle Program. This address will discuss the advantages and disadvantages, associated with the current state of the practice techniques and tools, used to automatically generate source code from general purpose and domain specific models. This address will discuss the obstacles and enablers, associated with achieving the desired future state of complete and efficient automated generation of programming through transformation of general purpose and domain specific models.

(Talk in PDF)^?

Abstract:

WebDSL is a domain-specific language for the implementation of dynamic web applications with a rich data model. It provides developers with object-oriented data modeling concepts but abstracts over implementation details for persisting application data in relational databases. When the underlying data model of an application evolves, persisted application data has to be migrated. While implementing migration at the database level breaks the abstractions provided by WebDSL, an implementation at the data model level requires to intermingle migration with application code. In this paper, we present a domain-specific language for the coupled evolution of data models and application data. It allows to specify data model evolution as a separate concern at the data model level and can be compiled to migration code at the database level. Its linguistic integration with WebDSL enables static checks for evolution validity and correctness.

Abstract:

The GeoGram system generates programs for geometric computations by combining generic software components as specified by diagrams constructed using a graphical interface. The user specifies known and desired quantities. As diagrams are constructed, the system maintains symbolic geometric facts describing the construction. Inferences based on the diagram are used to derive new facts and to introduce new objects based on geometric reasoning, to filter choices presented to the user, to interpret the user’s intention in ambiguous cases, to detect over-specification, and to generate the program. A knowledge base of descriptions of generic software components is used to prove that features of the geometry can be computed from known values. These local proofs are combined to guide generation of a program that computes the desired values from inputs. The library of generic geometric program components is used to generate both in-line code and specialized subroutines; partial evaluation improves the efficiency of the generated code. The resulting program is automatically translated into the desired language. The program can also be run interactively to simulate the geometry by generating graphical traces on the diagram as input quantities are varied.

Abstract:

Large software projects consist of code written in a multitude of different (possibly domain-specific) languages, which are often deeply interspersed even in single files. While many proposals exist on how to integrate languages semantically and syntactically, the question of how to support this scenario in integrated development environments (IDEs) remains open: How can standard IDE services, such as syntax highlighting, outlining, or reference resolving, be provided in an extensible and compositional way, such that an open mix of languages is supported in a single file? Based on our library-based syntactic extension language for Java, SugarJ, we propose to make IDEs extensible by organizing editor services in editor libraries. Editor libraries are libraries written in the object language, SugarJ, and hence activated and composed through regular import statements on a file-by-file basis. We have implemented an IDE for editor libraries on top of SugarJ and the Eclipse-based Spoofax language workbench. We have validated editor libraries by evolving this IDE into a fully-fledged and schema-aware XML editor as well as an extensible LATEX editor, which we used for writing this paper.

Abstract:

User interfaces exhibit a wide range of features that are designed to assist users. Interaction with one widget may trigger value changes, disabling, or other behaviors in other widgets. Such automatic behavior may be confusing or disruptive to users. Research literature on user interfaces offers a number of solutions, including interface features for explaining or controlling these behaviors. To help programmers help users, the implementation costs of these features need to be much lower. Ideally, they could be generated for “free.” This paper shows how several help and control mechanisms can be implemented as algorithms and reused across interfaces, making the cost of their adoption negligible. Specifically, we describe generic help mechanisms for visualizing data flow and explaining command deactivation, and a mechanism for controlling the flow of data. A reusable implementation of these features is enabled by our property model framework, where the data manipulated through a user interface is modeled as a constraint system.

Abstract: Writing correct and efficient concurrent programs still remains a challenge. Explicit concurrency is difficult, error prone, and creates code which is hard to maintain and debug. This type of concurrency also treats modular program design and concurrency as separate goals, where modularity often suffers.

To solve these problems, we are designing a new language that we call Panini. In this paper, we focus on Panini's asynchronous, typed events, which reconcile the modularity goal promoted by the implicit invocation design style with the concurrency goal of exposing potential concurrency between the execution of subjects and observers.

Since modularity is improved and concurrency is implicit in Panini, programs are easier to reason about and maintain. Furthermore, races and deadlocks are avoided entirely, yielding programs with a guaranteed sequential semantics.

To evaluate our language design and implementation we show several examples of its usage as well as an empirical study of program performance.

We found that not only is developing and understanding Panini programs significantly easier compared to standard concurrent object-oriented programs, but performance of Panini programs is also comparable to their equivalent hand-tuned versions written using Java's fork-join framework.

Important Dates

• Submission of abstracts: Saturday, May 21, 2011
• Submission of papers: Saturday, May 28, 2011
• Paper notification: Wednesday, July 6, 2011
• Camera ready papers: August 17, 2011

• Submission of tech talks: August 7, 2011
• Tech talks notification: August 26, 2011

• Conference: October 22-23, 2011

Abstract: Garcia introduces a calculus for type-reflective metaprogramming that provides much of the power and flexibility of C++ templates and solves many of its problems. However, one of the problems that remains is that the residual program is not type checked until after meta computation is complete. Ideally, one would like the type system of the metaprogram to also guarantee that the residual program will type check, as is the case in MetaML. However, in a language with type-reflective metaprogramming, type expressions in the residual program may be the result of meta computation, making the MetaML guarantee next to impossible to achieve.

In this paper we offer an approach to detecting errors earlier without sacrificing flexibility: we incrementally type check code fragments as they are created and spliced together during meta computation. The incremental type system is a variant of the gradual type system of Siek and Taha, in which we use type variables to represent type expressions that are not yet normalized and a new dynamic variation on existential types to represent residual code fragments. A type error in a code fragment is treated as a run-time error of the meta computation. We show that the incremental type checker can be implemented efficiently and we prove that if a well-typed metaprogram generates a residual program, then the residual program is also well-typed.

Abstract:

Enterprise distributed real-time and embedded (DRE) systems are increasingly being developed with the use of component-based software techniques. Unfortunately, commonly used component middleware platforms provide limited support for event-based publish/subscribe (pub/sub) mechanisms that meet both quality-ofservice (QoS) and configurability requirements of DRE systems. On the other hand, although pub/sub technologies, such as OMG Data Distribution Service (DDS), support a wide range of QoS settings, the level of abstraction they provide make it hard to con- figure them due to the significant source-level configuration that must be hard-coded at compile time or tailored at run-time using proprietary, ad hoc configuration logic. Moreover, developers of applications using native pub/sub technologies must write large amounts of boilerplate “glue” code to support run-time configuration of QoS properties, which is tedious and error-prone. This paper describes a novel, generative approach that combines the strengths of QoS-enabled pub/sub middleware with component-based middleware technologies. In particular, this paper describes the design and implementation of DDS4CIAO which addresses a number of inherent and accidental complexities in the DDS4CCM standard. DDS4CIAO simplifies the development, deployment, and configuration of component-based DRE systems that leverage DDS’s powerful QoS capabilities by provisioning DDS QoS policy settings and simplifying the development of DDS applications.

Abstract:

The adoption of a product line strategy can bring significant productivity and time to market improvements. However, evolving a product line is risky because it might impact many products and their users. So when evolving a product line to introduce new features or to improve its design, it is important to make sure that the behavior of existing products is not affected. In fact, to preserve the behavior of existing products one usually has to analyze different artifacts, like feature models, configuration knowledge and the product line core assets. To better understand this process, in this paper we discover and analyze concrete product line evolution scenarios and, based on the results of this study, we describe a number of safe evolution templates that developers can use when working with product lines. For each template, we show examples of their use in existing product lines. We evaluate the templates by also analyzing the evolution history of two different product lines and demonstrating that they can express the corresponding modifications and then help to avoid the mistakes that we identified during our analysis

Abstract: Type inference is the process of constructing a typing derivation while gradually discovering type information. During this process, inference algorithms typically make subtle decisions based on the derivation constructed so far.

Because a typing derivation is a decorated tree we aim to use attribute grammars as the main implementation tool. Unfortunately, we can neither express iteration, nor express decisions based on intermediate derivations in such grammars.

Here, we present the language |rulerfront|, a conservative extension to ordered attribute grammars, that deals with the aforementioned problems. We show why this extension is suitable for the description of constraint-based inference algorithms.

Abstract: Manually implementing equals (for object comparisons) and hashCode (for object hashing) methods in large software projects is tedious and error-prone. This is due to many special cases, such as field shadowing, comparison between different types, or cyclic object graphs. Here, we present JEqualityGen, a source code generator that automatically derives implementations of these methods.

JEqualityGen proceeds in two states: it first uses source code reflection in MetaAspectJ to generate aspects that contain the method implementations, before it uses weaving on the bytecode level to insert these into the target application. JEqualityGen generates not only correct, but efficient source code that on a typical large-scale Java application exhibits a performance improvement of more than two orders of magnitude in the equality operations generated, compared to an existing system based on runtime reflection. JEqualityGen achieves this by generating runtime profiling code that collects data. This enables it to generate optimised method implementations in a second round.

Abstract:

A code generator is a program translating an input model into code. In this paper we focus on template-based code generators in the context of the model view controller architecture (MVC). The language in which the code generator is written is known as a metalanguage in the code generation parlance. The metalanguage should be, on the one side, expressive enough to be of practical value, and, on the other side, restricted enough to enforce the separation between the view and the model, according to the MVC. In this paper we advocate the notion of unparser-complete metalanguages as providing the right level of expressivity. An unparsercomplete metalanguage is capable of expressing an unparser, a code generator that translates any legal abstract syntax tree into an equivalent sentence of the corresponding context-free language. A metalanguage not able to express an unparser will fail to produce all sentences belonging to the corresponding context-free language. A metalanguage able to express more than an unparser will also be able to implement code violating the model/view separation. We further show that a metalanguage with the power of a linear deterministic tree-to-string transducer is unparser-complete. Moreover, this metalanguage has been successfully applied in a nontrivial case study where an existing code generator is refactored using templates.

Abstract: Software engineering demands generality and abstraction, performance demands specialization and concretization. Generative programming can provide both, but developing high-quality program generators takes a large effort, even if a multi-stage programming language is used.

We present lightweight modular staging, a library-based multi-stage programming approach that breaks with the tradition of syntactic quasi-quotation and instead uses only types to distinguish between binding times. Through extensive use of component technology, lightweight modular staging makes an optimizing compiler framework available at the library level, allowing programmers to tightly integrate domain-specific abstractions and optimizations into the generation process.

We argue that lightweight modular staging enables a form of language virtualization, i.e. allows to go from a pure-library embedded language to one that is practically equivalent to a stand-alone implementation with only modest effort.

A Language for Software Variation Research

Martin Erwig, Oregon State University, USA

Managing variation is an important problem in software engineering that takes different forms, ranging from version control and configuration management to software product lines. In this talk, I present our recent work on the choice calculus, a fundamental representation for software variation that can serve as a common language of discourse for variation research, filling a role similar to lambda calculus in programming language research.

After motivating the design of the choice calculus and sketching its semantics, I will discuss several potential application areas.

Abstract: Modular robots are mechatronic devices that enable the construction of highly versatile and flexible robotic systems that can dynamically modify their assembled mechanical structure. The key feature that enables this dynamic modification is the capability of the individual modules to connect to each other in multiple ways and thus generate a number of different mechanical systems, in contrast with the monolithic, fixed structure of conventional robots. The mechatronic flexibility, however, complicates the development of models and programming abstractions for modular robots, since manually describing and enumerating the full set of possible interconnections is tedious and error-prone for real-world robots.

In order to allow for a general formulation of spatial abstractions for modular robots and to ensure correct and streamlined generation of code dependent on mechanical properties, we have developed the Mechatronics Description Language (MDL). MDL is a domain-specific language, which can model the kinematic structure of individual robot modules and declaratively describe their possible interconnections, rather than requiring the user to enumerate them in their entirety. From this description, the MDL compiler generates the code that is needed to simulate the resulting robots within Webots, a widely used commercial robot simulator, and the software component needed for spatial structure computations by a virtual machine-based runtime system, which we have developed and use for programming physical modular robots.

Abstract:

The development of service robots has gained more and more attention over the last years. A major challenge on the way towards industrial-strength service robotic systems is to make the step from code-driven to model-driven engineering. In this work we propose to put models into the focus of the whole life-cycle of robotic systems covering design-time as well as run-time. We describe how to explicate parameters, properties and resource information in the models at design-time and how to take these information into account by the run-time system of the robot to support its decision making process. We underpin our work by an exhaustive real-world example which is completely developed with our tools.

Abstract: Programs in domain-specific embedded languages (DSELs) can be represented in the host language in different ways, for instance implicitly as libraries, or explicitly in the form of abstract syntax trees. Each of these representations has its own strengths and weaknesses. The implicit approach has good composability properties, whereas the explicit approach allows more freedom in making syntactic program transformations.

Traditional designs for DSELs fix the form of representation, which means that it is not possible to choose the best representation for a particular interpretation or transformation. We propose a new design for implementing DSELs in Scala which makes it easy to use different program representations at the same time. It enables the DSL implementor to define modular language components and to compose transformations and interpretations for them.

Abstract:

The output of a code generator is assumed to be correct and not usually intended to be read or modified; yet programmers are often interested in this, e.g., to monitor a system property. Here, we consider code customization for a family of code generators associated with big-step executable modelling languages (e.g., statecharts). We introduce a customization language that allows us to express customization scenarios for the generated code independently of a specific big-step execution semantics. These customization scenarios are all different forms of runtime monitors, which lend themselves to a principled, uniform implementation for observation and code extension. A monitor is given in terms of the enabledness and execution of the transitions of a model and a reachability relation between two states of the execution of the model during a big step. For each monitor, we generate the aspect code that is incorporated into the output of a code generator to implement the monitor at the generated-code level. Thus, we provide means for code analysis through using the vocabulary of a model, rather than the detail of the generated code. Our technique not only requires the code generators to reveal only limited information about their code generation mechanisms, but also keeps the structure of the generated code intact. We demonstrate how various useful properties of a model, or a language, can be checked using our monitors.

Abstract:

During Software Product Line (SPL) maintenance tasks, Virtual Separation of Concerns (VSoC) allows the programmer to focus on one feature and hide the others. However, since features depend on each other through variables and control-flow, feature modularization is compromised since the maintenance of one feature may break another. In this context, emergent interfaces can capture dependencies between the feature we are maintaining and the others, making developers aware of dependencies. To better understand the impact of code level feature dependencies during SPL maintenance, we have investigated the following two questions: how often methods with preprocessor directives contain feature dependencies? How feature dependencies impact maintenance effort when using VSoC and emergent interfaces? Answering the former is important for assessing how often we may face feature dependency problems. Answering the latter is important to better understand to what extent emergent interfaces complement VSoC during maintenance tasks. To answer them, we analyze 43 SPLs of different domains, size, and languages. The data we collect from them complement previous work on preprocessor usage. They reveal that the feature dependencies we consider in this paper are reasonably common in practice; and that emergent interfaces can reduce maintenance effort during the SPL maintenance tasks we regard here.

Generative Programming and Component Engineering (GPCE'11)

Tenth International Conference
October 22-23, 2011
Portland, Oregon, USA
(collocated with SPLASH 2011)

Sponsored by ACM and SGT

Image used under GNU FDL.

Registration is at Salon Foyer (Hilton Executive Tower, downstairs)

Presentations are in Salon Ballroom I and II (Hilton Executive Tower, downstairs)

Breakfast will be served both days at 8:00 a.m. outside of these rooms.

It's your last chance to register for GPCE 2011. The program features keynotes by Matthias Felleisen (Northeastern University) and Gary Shubert (Lockheed Martin Space Systems Company), 18 technical talks covering theoretical and practical aspects of generative and component based programming, and two tech talks by Olivier Danvy (University of Aarhus) and John Launchbury (Galois, Inc.).

Generative and component approaches are revolutionizing software development just as automation and componentization revolutionized manufacturing. Key technologies for automating program development are Generative Programming for program synthesis, Component Engineering for modularity, and Domain-Specific Languages (DSLs) for compact problem-oriented programming notations.

The International Conference on Generative Programming and Component Engineering is a venue for researchers and practitioners interested in techniques that use program generation and component deployment to increase programmer productivity, improve software quality, and shorten the time-to-market of software products. In addition to exploring cutting-edge techniques of generative and component-based software, our goal is to foster further cross-fertilization between the software engineering and the programming languages research communities.

This year, the conference will be held in beautiful Portland. We invite you to join us.

GPCE variables:

• Set URLGPCE11 = http://gpce11.gpce.org
• Set GPCEDAYS = October 22-23, 2011
• Set GPCEDETAILDAYS = *Main Conference: Oct. 22-23, workshops and tutorials: *

• Set URLFLYER =
• Set URLFLYERALT = ?
• Set URLOOPSLA06 = ?
• Set URLLOCAL = ?
• Set URLPORTLAND = ?
• Set VENUE = ?
• Set VENUECITY = Portland, Oregon, USA

• Set PROPOSALSUBMISSION = ?
• Set PROPOSALNOTIFICATION = ?

• Set TECHTALKSSUBMISSION = August 7, 2011
• Set TECHTALKSNOTIFICATION = August 26, 2011
• Set OLDPAPERPRESUBMISSION = Monday, May 16, 2011
• Set OLDPAPERSUBMISSION = Sunday, May 22, 2011
• Set PAPERPRESUBMISSION = Saturday, May 21, 2011
• Set PAPERSUBMISSION = Saturday, May 28, 2011
• Set PAPERSUBMISSIONPOSTPONED = ?
• Set PAPERNOTIFICATION = Wednesday, July 6, 2011
• Set PAPERCAMERAREADY = August 17, 2011

• Set WORKSHOPSUBMISSION = *??, * (suggested)
• Set WORKSHOPNOTIFICATION = *??, * (suggested)
• Set WORKSHOPCAMERAREADY = *??, *
• Set TUTORIALCAMERAREADY = *??, *

• Set EARLYREGISTRATION = *??, *
• Set LATEREGISTRATION = *??, *

• Set WORKSHOPDAYS = ?

• Set GPCEVENUE = Gpce Venue

Preferences:

• Set WEBTITLE = Generative Programming and Component Engineering
• Set SHORTWEBTITLE = GPCE 2011

• List of topics of the TWiki.GPCE11 web:
  • Set WEBTOPICLIST = Home | Changes | Index | Search | Go

• Web specific background color: (Pick a lighter one of the StandardColors)
  • Set WEBBGCOLOR = #D0D0D0

• Exclude web from a web="all" search: (Set to on for hidden webs)
  • Set NOSEARCHALL =

• Default template for new topics and form(s) for this web:
  • WebTopicEditTemplate^?: Default template for new topics in this web. (Site-level is used if topic does not exist)
  • TWiki.WebTopicEditTemplate: Site-level default template
  • TWikiForms: How to enable form(s)
  • Set WEBFORMS =

• Users or groups who are not / are allowed to view / change / rename topics in the GPCE11 web: (See TWikiAccessControl)
  • Set DENYWEBVIEW =
  • Set ALLOWWEBVIEW =
  • Set DENYWEBCHANGE =
  • Set ALLOWWEBCHANGE = GpceorgGroup
  • Set DENYWEBRENAME =
  • Set ALLOWWEBRENAME = GpceorgGroup

• Users or groups allowed to change or rename this WebPreferences topic: (I.e. TWikiAdminGroup)
  • Set ALLOWTOPICCHANGE = TWikiAdminGroup GpceorgGroup
  • Set ALLOWTOPICRENAME = TWikiAdminGroup GpceorgGroup

• Web preferences that are not allowed to be overridden by user preferences:
  • Set FINALPREFERENCES = WEBTOPICLIST, DENYWEBVIEW, ALLOWWEBVIEW, DENYWEBCHANGE, ALLOWWEBCHANGE, DENYWEBRENAME, ALLOWWEBRENAME

Notes:

• A preference is defined as:
  6 spaces * Set NAME = value
  Example:
  • Set WEBBGCOLOR = #FFFFC0
• Preferences are used as TWikiVariables by enclosing the name in percent signs. Example:
  • When you write variable %WEBBGCOLOR% , it gets expanded to #D0D0D0 .
• The sequential order of the preference settings is significant. Define preferences that use other preferences first, i.e. set WEBCOPYRIGHT before WIKIWEBMASTER since %WEBCOPYRIGHT% uses the %WIKIWEBMASTER% variable.
• You can introduce new preferences variables and use them in your topics and templates. There is no need to change the TWiki engine (Perl scripts).

Related Topics:

• TWikiPreferences has site-level preferences.
• TWikiUsers has a list of user topics. User topics can have optional user preferences.
• TWikiVariables has a list of common %VARIABLES%.
• TWikiAccessControl explains how to restrict access by users or groups.

• Topic index: List of GPCE11 topics in alphabetical order.
  |All|A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z|
  | All topics in BookView |

• Jump to topic: If you already know the name of the topic, enter the name of the topic into the GoBox at the top

• WebChanges: Find out what topics in GPCE11 have changed recently

• How to edit text:
  • Make changes to topics in GoodStyle,
  • Learn the TextFormattingRules, and
  • Have a look at the TextFormattingFAQ

HistoricalStatistics^? for TWiki.GPCE11 Web

Notes:

• Do not edit this topic, it is updated automatically. (You can also force an update)
• TWikiDocumentation tells you how to enable the automatic updates of the statistics.
• Suggestion: You could archive this topic once a year and delete the previous year's statistics from the table.

• RoadMap^?
• WebIndex: all topics in the GPCE11 web
• WebSearch: find topics

Tracking activity

• WebNews: selected changes
• WebChanges: recent changes
• WebNotify: email notification of changes
• WebStatistics: usage counts

Look and feel

• WebPreferences: values of variables
• WebContents^?: web specific entries in the side bar